/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.ufpr.inf.escel.brain.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 *
 * @author gustavo
 */
public class PrimitivosUtils {

    /**
     * Verifica se o valor da string pode ser convertido
     * para inteiros.
     *
     * @param value da string
     * @return true || false
     * @since 2.6
     */
    public static boolean isInteger(String value) {
        try {
            Integer.parseInt(value);
        } catch (NumberFormatException nfe) {
            return false;
        }
        return true;
    }

    /**
     * Verifica se a string é uma palavra. Como definição de
     * palavra, eu adotei que seria qualquer ocorrencia > 1
     * de um caracter do alfabeto.
     *
     * @param value da string
     * @return true || false
     * @since 2.6
     */
    public static boolean isPalavra(String value) {
        //se existir só uma ocorrencia, é um caracter, e nao uma palavra
        if (value.length() == 1) {
            return false;
        }

        //verifica se todos os caraceteres são letras
        for (int i = 0; i < value.length(); i++) {
            if (!Character.isLetter(value.charAt(i))) {
                return false;
            }
        }

        return true;
    }

    /**
     * Converte um array de strings, para uma unica string
     * 
     * @param array a
     * @param separator
     * @return string
     */
    public static String arrayToString(String[] a, String separator) {

        StringBuffer result = new StringBuffer();

        int iMax = a.length - 1;

        for (int i = 0; i < a.length; i++) {
            if (a[i] == null && i == iMax) {
                int index = result.lastIndexOf(separator.trim());
                if (index != -1) {
                    result.deleteCharAt(index);
                }
            } else if (a[i] == null) {
                continue;
            } else {
                result.append(a[i]);
                if (i != iMax) {
                    result.append(separator);
                }
            }
        }

        return result.toString().trim();
    }

    /**
     * Converte um array de strings, para uma unica string
     *
     * @param array a
     * @param separator
     * @return string
     */
    public static String arrayToString(Number[] a, String separator) {

        StringBuffer result = new StringBuffer();

        int iMax = a.length - 1;

        for (int i = 0; i < a.length; i++) {
            if (a[i] == null && i == iMax) {
                int index = result.lastIndexOf(separator.trim());
                if (index != -1) {
                    result.deleteCharAt(index);
                }
            } else if (a[i] == null) {
                continue;
            } else {
                result.append(a[i]);
                if (i != iMax) {
                    result.append(separator);
                }
            }
        }

        return result.toString().trim();
    }

    /**
     * Converte uma coleção para uma unica string
     *
     * @param list a
     * @param separator
     * @return string
     * @since 3.1
     */
    public static String listToString(
            List a, String separator) {
        StringBuffer result = new StringBuffer();

        int iMax = a.size();

        for (int i = 0; i <
                a.size(); i++) {
            if (a.get(i) != null) {
                result.append(a.get(i));
                if (i != iMax - 1) {
                    result.append(separator);
                }

            }
        }
        return result.toString();
    }

    /**
     * Converte uma vetor de strings para array
     * 
     * @param vetor de strings
     * @return vetor convertido para list
     */
    public static ArrayList<String> arrayToList(String... values) {
        ArrayList<String> results = new ArrayList<String>();
        Collections.addAll(results, values);
        return results;
    }

    /**
     * Converte de list para array
     *
     * @param list
     * @return array
     * @since 3.9
     */
    public static String[] listToArray(List list) {
        return (String[]) list.toArray(new String[0]);
    }

    /**
     * Cria um novo array com o conteudo do array atual, mais o numero
     * de itens alocados passado por parametros
     * @param parametros
     * @return new Array size + 1
     * @since 4.1
     */
    public static String[] copyArray(String[] original, int numItens) {

        String[] novoArray = null;

        if (original != null) {
            novoArray = new String[original.length + numItens];

            //completa com os valores antigos
            for (int i = 0; i < original.length; i++) {
                novoArray[i] = original[i];
            }
        } else {
            novoArray = new String[numItens];
        }

        return novoArray;
    }

    /**
     * Recebe dois arrays e concatena os dois
     * @param original
     * @param novo
     * @return original + novo
     * @since 4.1
     */
    public static String[] copyArray(String[] original, String[] novo) {

        String[] novoArray = new String[original.length + novo.length];

        //completa com os valores antigos
        for (int i = 0; i < original.length; i++) {
            novoArray[i] = original[i];
        }

        //completa com os novos valores
        for (int i = 0; i < novo.length; i++) {
            novoArray[i + original.length] = novo[i];
        }

        return novoArray;
    }
}
